package cn.nawang.ebeim.api.controller;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import cn.nawang.ebeim.api.bean.CustomerBean;
import cn.nawang.ebeim.api.comm.BaseController;
import cn.nawang.ebeim.api.comm.PageList;
import cn.nawang.ebeim.api.comm.Pages;
import cn.nawang.ebeim.api.comm.SearchFormParams;
import cn.nawang.ebeim.api.domain.Customer;
import cn.nawang.ebeim.api.domain.SalesPackage;
import cn.nawang.ebeim.api.domain.User;
import cn.nawang.ebeim.api.service.CaService;
import cn.nawang.ebeim.api.service.CustomerService;
import cn.nawang.ebeim.api.service.DepartmentService;
import cn.nawang.ebeim.api.service.SalesPackageService;
import cn.nawang.ebeim.api.service.UserService;
import cn.nawang.ebeim.api.utils.Constant;
import cn.nawang.ebeim.api.utils.DateOperate;
import cn.nawang.ebeim.api.utils.DateUtils;
import cn.nawang.ebeim.api.utils.Util;
import cn.nawang.ebeim.api.utils.ValidateUtil;
import cn.nawang.ebeim.api.vo.UserView;

@RestController
@RequestMapping("/user")
public class CustomerController extends BaseController {
  private static final Logger LOG = LoggerFactory.getLogger(CustomerController.class);

  @Autowired
  private CustomerService customerService;
  @Autowired
  private UserService userService;
  @Autowired
  private CaService caService;
  @Autowired
  private DepartmentService departmentService;
  @Autowired
  private SalesPackageService salesPackageService;

  /**
   * @author 许炜毅
   * @Description 获取用户数据列表
   * @param page
   * @param request
   * @return PageList
   * @date 2015年8月6日下午3:57:34
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/list", method = RequestMethod.GET)
  public PageList getAllCustomers(Pages page, HttpServletRequest request) {
    LOG.debug("getAllCustomers {}", page);
    // 组装查询条件
    List<SearchFormParams> dtovect = new ArrayList<SearchFormParams>();

    // 部门编号
    String departId = request.getParameter("departId");
    if (!StringUtils.isEmpty(departId)) {
      String departIds = departmentService.findById(Integer.valueOf(departId));
      dtovect.add(new SearchFormParams("u.departmentId", departIds, "departIds",
          SearchFormParams.SELECT_IN_TYPE));
    }
    // 手机号
    String mobile = request.getParameter("mobile");
    if (!StringUtils.isEmpty(mobile)) {
      dtovect.add(new SearchFormParams("u.mobile", mobile, "mobile", SearchFormParams.STRING_TYPE));
    }
    // 姓名
    String name = request.getParameter("name");
    if (!StringUtils.isEmpty(name)) {
      dtovect.add(new SearchFormParams("u.name", name, "name", SearchFormParams.STRING_TYPE));
    }
    // 用户名
    String username = request.getParameter("username");
    if (!StringUtils.isEmpty(username)) {
      dtovect.add(
          new SearchFormParams("u.username", username, "username", SearchFormParams.STRING_TYPE));
    }
    // 客户编号
    User user = this.getUserLoginInfo(request);
    String customerId = user.getCustomerId();
    if (!StringUtils.isEmpty(customerId)) {
      dtovect.add(new SearchFormParams("u.customerId", customerId, "customerId",
          SearchFormParams.STRING_TYPE));
    }
    if (dtovect.size() > 0) {
      page.setSearchFormParams(dtovect.toArray(new SearchFormParams[dtovect.size() - 1]));
    }
    PageList pageList = customerService.getCustomers(page);
    LOG.debug("getAllCustomers {}", pageList);
    return pageList;
  }

  /**
   * @author 许炜毅
   * @Description 新增客户
   * @param user
   * @param request
   * @return Map<String,Object>
   * @date 2015年8月7日上午11:24:29
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/customer/add", method = RequestMethod.POST)
  public Map<String, Object> addAdmin(HttpServletRequest request, User user) {
    LOG.debug("/customer/add {}", user);
    Map<String, Object> resultMap = new HashMap<String, Object>();
    resultMap.put("code", Constant.CODE_ERROR);
    // 公司名称
    String companyName = request.getParameter("companyName");
    // 分配空间
    // String space = request.getParameter("spaceSize");
    // 使用类型
    String useType = request.getParameter("useType");

    String maxCopys = request.getParameter("maxCopys");
    // 加密狗ID
    String caIdJoinLabId = request.getParameter("caIdJoinLabId");
    // 确认密码
    String confirmPassword = request.getParameter("confirmPassword");
    // 销售套餐编号
    String salesPacakgeId = request.getParameter("salesPacakgeId");
    // 授权时长
    String authTime = request.getParameter("authTime");

    // 验证信息
    if (!validUserInfo(resultMap, user, companyName, useType, caIdJoinLabId, confirmPassword,
        maxCopys, authTime, salesPacakgeId)) {
      return resultMap;
    }

    if (customerService.saveAdminInfo(user, companyName, useType, caIdJoinLabId,
        getUserLoginInfo(request).getId(), Integer.valueOf(maxCopys), salesPacakgeId,
        Integer.valueOf(authTime))) {
      resultMap.put("code", Constant.CODE_SUCCESS);
      resultMap.put("desc", "添加成功。");
    } else {
      resultMap.put("desc", "服务器忙，请稍后再试。");
    }

    LOG.debug("addAdmin {}", user);
    return resultMap;
  }

  /**
   * 验证用户信息
   */
  public boolean validUserInfo(Map<String, Object> resultMap, User user, String companyName,
      String useType, String caIdJoinLabId, String confirmPassword, String maxCopys,
      String authTime, String salesPacakgeId) {
    SalesPackage salesPackage = salesPackageService.findOne(salesPacakgeId);
    if (Util.isBlank(companyName)) {
      resultMap.put("desc", "请输入公司名称。");
      return false;
    }
    // 判断公司名称是否存在
    if (customerService.findCustomerByName(companyName) != null) {
      resultMap.put("desc", "很抱歉，您输入的公司名称已存在。");
      return false;
    }
    if (Util.isBlank(maxCopys)) {
      resultMap.put("desc", "请输入最大备份数。");
      return false;
    }
    if (!Util.isPositiveIntegers(maxCopys)) {
      resultMap.put("desc", "最大备份数只允许输入正整数。");
      return false;
    }
    if (Util.isBlank(authTime)) {
      resultMap.put("desc", "请输入授权时长");
      return false;
    }
    if (!Util.isPositiveIntegers(authTime)) {
      resultMap.put("desc", "授权时长只允许输入正整数。");
    }
    if (Util.isBlank(caIdJoinLabId)) {
      resultMap.put("desc", "请输入加密狗ID，格式为：labId,caId,labType");
      return false;
    }
    String[] caIds = caIdJoinLabId.split("\r\n");
    if (caIds.length == 0) {
      resultMap.put("desc", "您输入的授权方式不能为空");
      return false;
    }
    if (caIds.length < (salesPackage.getUserCount() + 1)) {
      resultMap.put("desc", "您授权方式的个数小于套餐的用户的个数，请核查。");
      return false;
    }
    if (caIds.length > (salesPackage.getUserCount() + 1)) {
      resultMap.put("desc", "您的授权方式的个数大于套餐的用户个数,请核查");
      return false;
    }
    for (int i = 0; i < caIds.length; i++) {
      // 授权格式校验
      if (caIds[i].split(",").length != 3) {
        resultMap.put("desc", "您输入的第" + (i + 1) + "个授权方式不正确，正确格式为：labId,caId,labType");
        return false;
      }
      // 判断输入值中是否已经有重复
      for (int j = 0; j < caIds.length; j++) {
        // 判断输入值中的labId是否存在（授权内容）
        if (caIds[i].split(",")[0].equals(caIds[j].split(",")[0]) && i != j) {
          resultMap.put("desc", "很抱歉，您输入的第" + (i + 1) + "个和第" + (j + 1) + "个授权方式中的labId为："
              + caIds[i].split(",")[0] + "重复，请修改。");
          return false;
        }
        // 判断输入值中的caId是否存在（主键）
        if (caIds[i].split(",")[1].equals(caIds[j].split(",")[1]) && i != j) {
          resultMap.put("desc", "很抱歉，您输入的第" + (i + 1) + "个和第" + (j + 1) + "个授权方式中的caId为："
              + caIds[i].split(",")[1] + "重复，请修改。");
          return false;
        }
      }
      // 判断Ca中的labId是否存在（授权内容）
      if (caService.findByLabId(caIds[i].split(",")[0]) != null) {
        resultMap.put("desc",
            "很抱歉，您输入的第" + (i + 1) + "个授权方式中的labId为：" + caIds[i].split(",")[0] + "已存在。");
        return false;
      }
      // 判断Ca中的caId是否存在（主键）
      if (caService.findOne(caIds[i].split(",")[1]) != null) {
        resultMap.put("desc",
            "很抱歉，您输入的第" + (i + 1) + "个授权方式中的caId为：" + caIds[i].split(",")[1] + "已存在。");
        return false;
      }

      if (!caIds[i].split(",")[2].equals("0") && !caIds[i].split(",")[2].equals("1")
          && !caIds[i].split(",")[2].equals("2") && !caIds[i].split(",")[2].equals("3")
          && !caIds[i].split(",")[2].equals("4")) {
        resultMap.put("desc", "很抱歉，您输入的第" + (i + 1) + "个授权方式中的labType为：" + caIds[i].split(",")[2]
            + "不正确。" + "请输入：0或者1或者2或者3或者4（0代表无授权，1代表的是key无关联，2代表的是授权码，" + "3代表key关联设备,4代表授权码关联设备）");
        return false;
      }

    }
    // 用户名
    String username = user.getUsername();
    if (Util.isBlank(username)) {
      resultMap.put("desc", "请输入用户名");
      return false;
    }
    // 密码
    String password = user.getPassword();
    if (Util.isBlank(password)) {
      resultMap.put("desc", "请输入密码");
      return false;
    }
    if (Util.isBlank(confirmPassword)) {
      resultMap.put("desc", "请输入确认密码");
      return false;
    }
    if (!Util.pwdFormat(confirmPassword)) {
      resultMap.put("desc", "至少六位的英文数字组合");
      return false;
    }
    if (!password.equals(confirmPassword)) {
      resultMap.put("desc", "很抱歉，您输入的两次密码不一致。");
      return false;
    }
    // 真实姓名
    String name = user.getName();
    if (Util.isBlank(name)) {
      resultMap.put("desc", "请输入真实姓名");
      return false;
    }
    // 电子邮箱
    String email = user.getEmail();
    if (Util.isBlank(email)) {
      resultMap.put("desc", "请输入电子邮箱");
      return false;
    }
    if (!Util.emailFormat(email)) {
      resultMap.put("desc", "请输入合法的电子邮箱，格式：nawang@163.com");
      return false;
    }
    // 手机号码
    String mobile = user.getMobile();
    if (Util.isBlank(mobile)) {
      resultMap.put("desc", "请输入手机号码");
      return false;
    }
    if (!Util.isNumeric(mobile) || mobile.length() != 11) {
      resultMap.put("desc", "请输入合法的手机号，如：13400000000。");
      return false;
    }
    User us = userService.findUserByUsernameOrMobileOrEmail(username, null, null);
    if (us != null) {
      if (username.equals(us.getUsername())) {
        resultMap.put("desc", "很抱歉，您输入的用户名已存在。");
        return false;
      }
//      if (mobile.equals(us.getMobile())) {
//        resultMap.put("desc", "很抱歉，您输入的手机号已存在。");
//        return false;
//      }
//      if (email.equals(us.getEmail())) {
//        resultMap.put("desc", "很抱歉，您输入的电子邮箱已存在。");
//        return false;
//      }
    }
    return true;
  }

  /**
   * @author 许炜毅
   * @Description 公司名称唯一性验证
   * @param companyName
   * @return Map<String,String>
   * @date 2015年8月7日下午4:14:31
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/customer/valid", method = RequestMethod.GET)
  public Map<String, Object> validCompanyName(String companyName) {
    LOG.debug("/customer/valid {}", companyName);
    Map<String, Object> resultMap = new HashMap<String, Object>();
    resultMap.put("code", Constant.CODE_ERROR);
    if (Util.isBlank(companyName)) {
      resultMap.put("desc", "参数错误。");
    }
    Customer cu = customerService.findCustomerByName(companyName);
    if (cu != null) {
      resultMap.put("desc", "很抱歉，您输入的公司名称已存在。");
    } else {
      resultMap.put("code", Constant.CODE_SUCCESS);
      resultMap.put("desc", "此名称可以使用。");
    }
    LOG.debug("validCompanyName {}", companyName);
    return resultMap;
  }

  /**
   * @author 许炜毅
   * @Description 获取客户信息列表
   * @param currPage
   * @param pageSize
   * @return PageList
   * @date 2015年8月7日下午4:24:09
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/customer/list", method = RequestMethod.GET)
  public PageList customerList(Pages page, HttpServletRequest request) {
    LOG.debug("/customer/list {}", page);
    // 组装查询条件
    List<SearchFormParams> dtovect = new ArrayList<SearchFormParams>();
    String name = request.getParameter("name");
    if (!StringUtils.isEmpty(name)) {
      dtovect.add(new SearchFormParams("c.name", name, "name", SearchFormParams.STRING_TYPE));
    }
    // 起始时间
    String startTime = request.getParameter("startTime");
    if (!StringUtils.isEmpty(startTime)) {
      Date date = DateOperate.formatStringToDate(startTime, DateOperate.DEFAULTSTYLE);
      dtovect.add(new SearchFormParams("c.createTime", date.getTime(), "startTime",
          SearchFormParams.START_TIME_TYPE));
    }

    // 结束时间
    String endTime = request.getParameter("endTime");
    if (!StringUtils.isEmpty(endTime)) {
      Date date = DateOperate.formatStringToDate(endTime, DateOperate.DEFAULTSTYLE);
      long endTimeLong = DateUtils.getDateEndTime(date);
      dtovect.add(new SearchFormParams("c.createTime", endTimeLong, "endTime",
          SearchFormParams.END_TIME_TYPE));
    }
    if (dtovect.size() > 0) {
      page.setSearchFormParams(dtovect.toArray(new SearchFormParams[dtovect.size() - 1]));
    }
    LOG.debug("customerList {}", page);
    return customerService.findCustomerList(page);
  }

  /**
   * @author 许炜毅
   * @Description 验证用户名、手机号、电子邮箱是否重复
   * @param validType
   * @param request
   * @param @return
   * @return Map<String,Object>
   * @date 2015年8月7日下午4:36:23
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/valid", method = RequestMethod.GET)
  public Map<String, Object> validUserBaseInfo(String validType, HttpServletRequest request) {
    LOG.debug("/valid {}", validType);
    Map<String, Object> resultMap = new HashMap<String, Object>();
    // 用户名
    String username = request.getParameter("username");
    // 手机号
    String mobile = request.getParameter("mobile");
    // 电子邮箱
    String email = request.getParameter("email");
    // 用户名验证
    if ("0".equals(validType)) {
      if (Util.isBlank(username)) {
        resultMap.put("code", Constant.CODE_ERROR);
        resultMap.put("desc", "参数有误。");
        return resultMap;
      }
      if (userService.findUserByUsername(username) != null) {
        resultMap.put("code", Constant.CODE_ERROR);
        resultMap.put("desc", "很抱歉，用户名已存在。");
      } else {
        resultMap.put("code", Constant.CODE_SUCCESS);
        resultMap.put("desc", "恭喜您，此用户名可以正常使用。");
      }
    }
    // 电子邮箱验证
    if ("1".equals(validType)) {
      if (Util.isBlank(email)) {
        resultMap.put("code", Constant.CODE_ERROR);
        resultMap.put("desc", "参数有误。");
        return resultMap;
      }
      if (!Util.emailFormat(email)) {
        resultMap.put("code", Constant.CODE_ERROR);
        resultMap.put("desc", "请输入合法的电子邮箱，格式：nawang@163.com");
        return resultMap;
      }
//      if (userService.findUserByEmail(email) != null) {
//        resultMap.put("code", Constant.CODE_ERROR);
//        resultMap.put("desc", "很抱歉，电子邮箱已存在。");
//      } else {
//        resultMap.put("code", Constant.CODE_SUCCESS);
//        resultMap.put("desc", "恭喜您，此电子邮箱可以正常使用。");
//      }
    }
    // 手机号验证
    if ("2".equals(validType)) {
      if (Util.isBlank(mobile)) {
        resultMap.put("code", Constant.CODE_ERROR);
        resultMap.put("desc", "参数有误。");
        return resultMap;
      }
      if (!Util.isNumeric(mobile) || mobile.length() != 11) {
        resultMap.put("code", Constant.CODE_ERROR);
        resultMap.put("desc", "请输入合法的手机号，如：13400000000。");
        return resultMap;
      }
//      if (userService.findUserByMobile(mobile) != null) {
//        resultMap.put("code", Constant.CODE_ERROR);
//        resultMap.put("desc", "很抱歉，手机号已存在。");
//      } else {
//        resultMap.put("code", Constant.CODE_SUCCESS);
//        resultMap.put("desc", "恭喜您，此手机号可以正常使用。");
//      }
    }
    LOG.debug("validUserBaseInfo {}", resultMap);
    return resultMap;
  }

  /**
   * @author 许炜毅
   * @Description 批量转移用户到指定部门
   * @param departId
   * @param userIdStr
   * @return Map<String,Object>
   * @date 2015年8月7日下午4:48:36
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/transfer", method = RequestMethod.GET)
  public Map<String, Object> batchTransferUser(int departId, String userIdStr) {
    LOG.debug("/transfer {}", departId, userIdStr);
    Map<String, Object> resultMap = new HashMap<String, Object>();
    boolean rt = customerService.batchTransferUser(departId, userIdStr);
    if (rt) {
      resultMap.put("code", Constant.CODE_SUCCESS);
      resultMap.put("desc", "用户分配成功！");
    } else {
      resultMap.put("code", Constant.CODE_ERROR);
      resultMap.put("desc", "服务器忙，请稍后再试。");
    }
    LOG.debug("batchTransferUser {}", resultMap);
    return resultMap;
  }

  /**
   * @author 许炜毅
   * @Description 新增用户
   * @param user
   * @return Map<String,Object>
   * @date 2015年8月7日下午5:43:48
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/add", method = RequestMethod.POST)
  public Map<String, Object> add(User user, HttpServletRequest request) {
    LOG.debug("/add {}", user);
    Map<String, Object> resultMap = new HashMap<String, Object>();
    resultMap.put("code", Constant.CODE_ERROR);
    // 获取登录者信息
    User us = this.getUserLoginInfo(request);
    user.setCustomerId(us.getCustomerId());
    // 验证信息
    if (validUser(resultMap, user, "0")) {

      user.setCreateUserId(us.getId());// 创建者编号
      user.setIsFirstLogin(Constant.USER_IS_FIRST_LOGIN_YES);
      // 给用户设置
      SalesPackage salesPackage = salesPackageService.findByCustomerId(user.getCustomerId());
      user.setSpaceSize(salesPackage.getEachUserSpaceSize());

      // 修改adminUser已用的空间
      User adminUser = userService.findByCustomerIdAndAdmin(user.getCustomerId());
      int spaceCapacity =
          Integer.valueOf(adminUser.getSpaceCapacity()) + Integer.valueOf(user.getSpaceSize());
      adminUser.setSpaceCapacity(String.valueOf(spaceCapacity));
      boolean adminUserFlag = userService.update(adminUser);
      boolean flag = userService.save(user);
      if (flag && adminUserFlag) {
        resultMap.put("code", Constant.CODE_SUCCESS);
        resultMap.put("desc", "用户添加成功。");
      } else {
        resultMap.put("desc", "服务器忙，请稍后再试。");
      }
    }
    LOG.debug("add {}", resultMap);
    return resultMap;
  }

  /**
   * @author 许炜毅
   * @Description 新增/修改用户资料验证
   * @param resultMap
   * @param user
   * @param oprFlag(0：新增，1：修改)
   * @return boolean
   * @date 2015年8月10日下午5:26:51
   *
   * @修改人
   * @修改日期
   */
  public boolean validUser(Map<String, Object> resultMap, User user, String oprFlag) {
    if (ValidateUtil.isEmpty(user.getId()) && Util.isBlank(user.getLabId())) {
      resultMap.put("desc", "很抱歉，您的授权编码已用完，您已无法新增用户，请联系客服人员。");
      return false;
    }
    User adminUser = userService.findByCustomerIdAndAdmin(user.getCustomerId());
    double availableSpace = Double.valueOf(adminUser.getSpaceSize())
        - Double.valueOf(user.getSpaceCapacity() == null ? "0" : user.getSpaceCapacity());
    if (Util.isBlank(user.getName())) {
      resultMap.put("desc", "请输入真实姓名。");
      return false;
    }
    // 验证用户名
    if (Util.isBlank(user.getUsername())) {
      resultMap.put("desc", "请输入用户名。");
      return false;
    }
    // 判断用户状态，如果为空，则默认为"正常"
    if (Util.isBlank(user.getStatus())) {
      user.setStatus(Constant.USER_STATUS_TYPE_ZERO);
    }
    // 验证机构
    if (Util.isBlank(user.getDepartmentId())) {
      resultMap.put("desc", "请选择所属机构。");
      return false;
    }
    // 验证部门
    if (Util.isBlank(user.getDepartmentId())) {
      resultMap.put("desc", "请选择机构下所对应的部门。");
      return false;
    }

    // 验证手机号
    if (Util.isBlank(user.getMobile())) {
      resultMap.put("desc", "请输入移动电话。");
      return false;
    }
    if (!Util.isNumeric(user.getMobile()) || user.getMobile().length() != 11) {
      resultMap.put("desc", "请输入合法的手机号，如：13400000000。");
      return false;
    }
    // 验证邮箱
    if (Util.isBlank(user.getEmail())) {
      resultMap.put("desc", "请输入电子邮箱。");
      return false;
    }
    if (!Util.emailFormat(user.getEmail())) {
      resultMap.put("desc", "请输入合法的电子邮箱，格式：nawang@163.com");
      return false;
    }

    User us = null;
    if ("0".equals(oprFlag)) {
      // 验证密码
      if (Util.isBlank(user.getPassword())) {
        resultMap.put("desc", "请输入密码。");
        return false;
      }
      if (!Util.pwdFormat(user.getPassword())) {
        resultMap.put("desc", "至少六位的英文数字组合。");
        return false;
      }
      // 新增验证
      us = userService.findUserByUsernameOrMobileOrEmail(user.getUsername(), null,
          null);
      if (us != null) {
        if (user.getUsername().equals(us.getUsername())) {
          resultMap.put("desc", "很抱歉，您输入的用户名已存在。");
          return false;
        }
//        if (user.getMobile().equals(us.getMobile())) {
//          resultMap.put("desc", "很抱歉，您输入的手机号已存在。");
//          return false;
//        }
//        if (user.getEmail().equals(us.getEmail())) {
//          resultMap.put("desc", "很抱歉，您输入的电子邮箱已存在。");
//          return false;
//        }
      }
    } else {
      // 修改验证
      us = userService.findUserByUsernameOrMobileOrEmailNotId(user.getUsername(), null,
         null, user.getId());
      if (us != null) {
        if (user.getUsername().equals(us.getUsername()) && !user.getId().equals(us.getId())) {
          resultMap.put("desc", "很抱歉，您输入的用户名已存在。");
          return false;
        }
//        if (user.getMobile().equals(us.getMobile()) && !user.getId().equals(us.getId())) {
//          resultMap.put("desc", "很抱歉，您输入的手机号已存在。");
//          return false;
//        }
//        if (user.getEmail().equals(us.getEmail()) && !user.getId().equals(us.getId())) {
//          resultMap.put("desc", "很抱歉，您输入的电子邮箱已存在。");
//          return false;
//        }
      }
    }
    return true;
  }

  /**
   * @author 许炜毅
   * @Description 根据用户编号，获取单个用户基本资料
   * @param userId 用户编号
   * @return Map<String,Object>
   * @date 2015年8月10日上午11:08:20
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/get", method = RequestMethod.GET)
  public Map<String, Object> findUserById(String userId) {
    LOG.debug("/get {}", userId);
    Map<String, Object> resultMap = new HashMap<String, Object>();
    UserView uv = userService.findUserById(userId);
    if (uv != null) {
      resultMap.put("code", Constant.CODE_SUCCESS);
      resultMap.put("desc", "数据查询成功。");
      resultMap.put("obj", uv);
    } else {
      resultMap.put("code", Constant.CODE_ERROR);
      resultMap.put("desc", "很抱歉，没找到您要的信息。");
      resultMap.put("obj", null);
    }
    LOG.debug("findUserById {}", resultMap);
    return resultMap;
  }



  /**
   * @author 许炜毅
   * @Description 获取用户状态
   * @param @return
   * @return Map<String,Object>
   * @date 2015年8月7日上午11:25:39
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/get_status", method = RequestMethod.GET)
  public Map<String, Object> getUserStatus() {
    LOG.debug("/get_status {}");
    Map<String, Object> resultMap = new HashMap<String, Object>();
    resultMap.put("code", Constant.CODE_SUCCESS);
    resultMap.put("desc", "获取数据成功。");

    List<Map> mapList = new ArrayList<Map>();
    for (Map.Entry<String, String> map : Constant.USER_STATUS_TYPE.entrySet()) {
      Map<String, Object> statusMap = new HashMap<String, Object>();
      statusMap.put("id", map.getKey());
      statusMap.put("name", map.getValue());
      mapList.add(statusMap);
    }
    resultMap.put("statusList", mapList);
    LOG.debug("getUserStatus {}", resultMap);
    return resultMap;
  }

  /**
   * @author 许炜毅
   * @Description 进入修改用户基本资料界面
   * @param userId 用户编号
   * @param request
   * @return Map<String,Object>
   * @date 2015年8月10日上午11:29:42
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/update/get", method = RequestMethod.GET)
  public Map<String, Object> getUserUpdateData(String userId, HttpServletRequest request) {
    LOG.debug("getUserStatus {}", userId);
    Map<String, Object> map = new HashMap<String, Object>();
    map = userService.intoUpdateUser(userId);
    LOG.debug("getUserUpdateData {}", userId);
    return map;
  }

  /**
   * @author 许炜毅
   * @Description 更新用户资料
   * @param user
   * @param request
   * @return Map<String,Object>
   * @date 2015年8月10日下午4:26:59
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/update", method = RequestMethod.POST)
  public Map<String, Object> updateUser(User user, HttpServletRequest request) {
    LOG.debug("/update {}", user);
    Map<String, Object> resultMap = new HashMap<String, Object>();
    resultMap.put("code", Constant.CODE_ERROR);
    // 获取登录者信息
    User us = this.getUserLoginInfo(request);
    user.setCustomerId(us.getCustomerId());
    if (Util.isBlank(user.getId())) {
      resultMap.put("desc", "用户编号不允许为空。");
      return resultMap;
    }
    // 验证信息
    if (validUser(resultMap, user, "1")) {
      Date d = new Date();
      User oldUser = userService.findOne(user.getId());
      user.setCreateTime(oldUser.getCreateTime());
      user.setCreateUserId(oldUser.getCreateUserId());
      user.setIsUpdateDefaultPwd(oldUser.getIsUpdateDefaultPwd());
      user.setLmTime(d.getTime());
      user.setLmUserId(us.getId());
      user.setPassword(oldUser.getPassword());
      user.setUpdatePassTime(oldUser.getUpdatePassTime());

      user.setLabId(oldUser.getLabId());
      user.setRole(oldUser.getRole());
      user.setLabType(oldUser.getLabType());

      user.setIsFirstLogin(oldUser.getIsFirstLogin());
      user.setSpaceSize(oldUser.getSpaceSize());
      user.setSafeLevel(oldUser.getSafeLevel());
      user.setSpaceCapacity(oldUser.getSpaceCapacity());
      user.setBindDevice(oldUser.getBindDevice());
      user.setBindTime(oldUser.getBindTime());
      boolean flag = userService.update(user);
      if (flag) {
        resultMap.put("code", Constant.CODE_SUCCESS);
        resultMap.put("desc", "更新成功。");
        return resultMap;
      } else {
        resultMap.put("desc", "服务器忙，请稍后再试。");
        return resultMap;
      }
    }
    LOG.debug("updateUser {}", resultMap);
    return resultMap;
  }

  /**
   * @author 许炜毅
   * @Description 修改用户密码
   * @param userId
   * @param oldPassword
   * @param newPassword
   * @return Map<String,Object>
   * @date 2015年8月10日上午11:36:31
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/update_password", method = RequestMethod.POST)
  public Map<String, Object> updatePassword(String userId, String oldPassword, String newPassword,
      HttpServletRequest request) {
    LOG.debug("/update_password {}", userId, oldPassword, newPassword);
    Map<String, Object> resultMap = new HashMap<String, Object>();
    // 获取登录者信息
    User us = this.getUserLoginInfo(request);
    if (Util.isBlank(userId)) {
      resultMap.put("code", Constant.CODE_ERROR);
      resultMap.put("desc", "参数有误。");
      return resultMap;
    }
    if (Util.isBlank(oldPassword)) {
      resultMap.put("code", Constant.CODE_ERROR);
      resultMap.put("desc", "请输入旧密码。");
      return resultMap;
    }
    if (Util.isBlank(newPassword)) {
      resultMap.put("code", Constant.CODE_ERROR);
      resultMap.put("desc", "请输入新密码。");
      return resultMap;
    }
    if(oldPassword.equals(newPassword)){
      resultMap.put("code", Constant.CODE_ERROR);
      resultMap.put("desc", "新密码与旧密码不能相同。");
      return resultMap;
    }
    if (!Util.pwdFormat(newPassword)) {
      resultMap.put("desc", "至少六位的英文数字组合。");
      return resultMap;
    }
    User user = userService.findOne(userId);
    if (user == null) {
      resultMap.put("code", Constant.CODE_ERROR);
      resultMap.put("desc", "很抱歉，您要修改的用户不存在。");
      return resultMap;
    }
    if (!user.getPassword().toUpperCase().equals(Util.hash(oldPassword))) {
      resultMap.put("code", Constant.CODE_ERROR);
      resultMap.put("desc", "很抱歉，您输入的旧密码有误。");
      return resultMap;
    }
    user.setPassword(Util.hash(newPassword));
    user.setIsUpdateDefaultPwd(Constant.YES);
    user.setLmTime(new Date().getTime());
    user.setLmUserId(us.getId());
    user.setUpdatePassTime(new Date().getTime());
    boolean flag = userService.update(user);
    if (flag) {
      resultMap.put("code", Constant.CODE_SUCCESS);
      resultMap.put("desc", "密码修改成功。");
    } else {
      resultMap.put("code", Constant.CODE_ERROR);
      resultMap.put("desc", "服务器忙，请稍后再试。");
    }
    LOG.debug("/update_password {}", resultMap);
    return resultMap;
  }

  /**
   * @author 许炜毅
   * @Description 获取用户使用类型
   * @return Map<String,Object>
   * @date 2015年8月7日上午11:27:49
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/get_type", method = RequestMethod.GET)
  public Map<String, Object> getUserIsUseType() {
    LOG.debug("/get_type {}");
    Map<String, Object> resultMap = new HashMap<String, Object>();
    resultMap.put("code", Constant.CODE_SUCCESS);
    resultMap.put("desc", "获取数据成功。");

    List<Map> mapList = new ArrayList<Map>();
    for (Map.Entry<String, String> map : Constant.USER_TYPE.entrySet()) {
      Map<String, Object> statusMap = new HashMap<String, Object>();
      statusMap.put("id", map.getKey());
      statusMap.put("name", map.getValue());
      mapList.add(statusMap);
    }
    resultMap.put("statusList", mapList);
    LOG.debug("getUserIsUseType {}", resultMap);
    return resultMap;
  }

  /**
   * 
   * @author fanyb
   * @Description: 根据终端编号查找客户对象
   * @param terminalId 终端编号
   * @return Map<String,Object> 返回结果
   * @date Aug 19, 201510:27:08 AM
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/token/customer/find/terminalId", method = RequestMethod.GET)
  public Map<String, Object> getCustomerByTerminalId(String terminalId) {
    LOG.debug("/token/customer/find/terminalId {}", terminalId);
    Map<String, Object> resultMap = new HashMap<String, Object>();
    resultMap.put("code", Constant.CODE_ERROR);
    resultMap.put("object", customerService.findCustomerByTerminalId(terminalId));
    resultMap.put("code", Constant.CODE_SUCCESS);
    LOG.debug("getCustomerByTerminalId {}", resultMap);
    return resultMap;
  }

  /**
   * 
   * @author fanyb
   * @Description: 查找某用户总共有多少空间，以及还有多少可分配空间
   * @param request
   * @return Map<String,Object>
   * @date Oct 22, 20155:24:30 PM
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/customer/available_space", method = RequestMethod.GET)
  public Map<String, Object> findUserAvailableSpace(HttpServletRequest request) {
    LOG.debug("/customer/available_space {}");
    User user = getUserLoginInfo(request);
    Map<String, Object> map = userService.findUserAvailableSpace(user.getCustomerId());
    LOG.debug("findUserAvailableSpace {}", map);
    return map;
  }

  /**
   * 
   * @author fanyb
   * @Description: 给用户追加空间
   * @param id
   * @param addSpaceSize
   * @return Map<String,Object>
   * @date Oct 23, 20155:45:01 PM
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/add_space", method = RequestMethod.GET)
  public Map<String, Object> addSpaceSize(String id, String spaceSize, HttpServletRequest request) {
    LOG.debug("/add_space {}", id, spaceSize);
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("code", Constant.CODE_ERROR);
    userService.addSpaceSize(id, spaceSize);
    map.put("desc", "追加成功。");
    map.put("code", Constant.CODE_SUCCESS);
    LOG.debug("addSpaceSize {}", map);
    return map;
  }

  /**
   * 
   * @author fanyb
   * @Description: TODO
   * @param id
   * @param spaceSize
   * @param request
   * @return Map<String,Object>
   * @date Oct 24, 20158:42:43 AM
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/token/customer_key", method = RequestMethod.GET)
  public Map<String, Object> findCustomerKeyByCustomerId(String customerId,
      HttpServletRequest request) {
    LOG.debug("/token/customer_key {}", customerId);
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("code", Constant.CODE_ERROR);
    Customer customer = customerService.findOne(customerId);
    map.put("obj", customer);
    map.put("code", Constant.CODE_SUCCESS);
    LOG.debug("findCustomerKeyByCustomerId {}", map);
    return map;
  }

  /**
   * 
   * @author fanyb
   * @Description: 根据用户名查找用户对象
   * @param username
   * @return Map<String,Object>
   * @date Nov 5, 20159:34:29 AM
   *
   * @修改人
   * @修改日期
   */
  @RequestMapping(value = "/token/username", method = RequestMethod.GET)
  public Map<String, Object> findByUsername(String username) {
    LOG.debug("/token/username {}", username);
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("code", Constant.CODE_ERROR);
    User user = userService.findUserByUsername(username);
    boolean valid = validUserName(map, username, user);
    if (!valid) {
      return map;
    }
    map.put("obj", user);
    map.put("code", Constant.CODE_SUCCESS);
    LOG.debug("findByUsername {}", map);
    return map;
  }

  /**
   * 
   * @author fanyb
   * @Description: 根据用户名查找用户验证方法
   * @param map
   * @param username
   * @param user
   * @return boolean
   * @date Nov 5, 201511:18:21 AM
   *
   * @修改人
   * @修改日期
   */
  public boolean validUserName(Map<String, Object> map, String username, User user) {
    if (Util.isBlank(username)) {
      map.put("desc", "请输入用户名。");
      return false;
    }
    if (ValidateUtil.isNull(user)) {
      map.put("desc", "用户不存在。");
      return false;
    }
    if (user.getStatus().equals(Constant.USER_STATUS_TYPE_ONE)) {
      map.put("desc", "用户已经停用。");
      return false;
    }
    return true;
  }
  
  /**
   * 
   * @author fanyb
   * @Description: 查看用户详情
   * @param id
   * @return Map<String,Object> 
   * @date Dec 2, 201511:16:46 AM
   *
   * @修改人 
   * @修改日期
   */
  @RequestMapping(value = "/customer/detail", method = RequestMethod.GET)
  public Map<String, Object> findCustomerBean(String customerId) {
    LOG.debug("/customer/detail {}", customerId);
    Map<String, Object> map = new HashMap<String, Object>();
    map.put("code", Constant.CODE_ERROR);
    CustomerBean customerBean = customerService.findCustomerBean(customerId);
    map.put("obj", customerBean);
    map.put("code", Constant.CODE_SUCCESS);
    LOG.debug("/customer/detail {}", map);
    return map;
  }
}
